import java.util.Enumeration;
import java.util.Hashtable;
import javax.microedition.rms.RecordEnumeration;
import javax.microedition.rms.RecordStore;
import javax.microedition.rms.RecordStoreException;


/*

Un record esr forme a partir d'un tableau de character char[36]

 --------------------------------------------------------------
| val1 | val2 | val3 | val4 | val5 | min  | max  | moy  |offset|
 --------------------------------------------------------------
        <----->
		4 bytes
		
 offset: compteur circulaire pour indiquer ou mettre la prochaine valeur
 
*/
class DataRecord {

  private String mRecordStoreName; 
  private Hashtable mHashtable;
  private String currentNodeProcessed;
  private RecordStore rs;

  private static final int MIN=20; //indique l'emplacement dans le record
  private static final int MAX=24;
  private static final int MOY=28;
  private static final int OFFSET=32;
  
  
  public DataRecord(String recordStoreName)  {
    mRecordStoreName = recordStoreName;
    mHashtable = new Hashtable();
   
  }

  /*
  * retourne le nom du recordStore
  */
  public String getName(){
  
	return mRecordStoreName;
  
  }
  
  /*
  * retourne les valeurs min, max et moy d'un record
  */
  public String getStat(int recId)throws RecordStoreException {
  
    rs = RecordStore.openRecordStore(mRecordStoreName, true);
	char[] data=new String(rs.getRecord(recId)).toCharArray();
	
	if (rs != null)
		rs.closeRecordStore();
		
    return "min "+getVal(MIN, data)+" max "+getVal(MAX, data)+" moy "+getVal(MOY, data)+"\n";
  }
  
  /*
  * retourne la liste de noeuds qu'on vigile
  */
  public String[] getList() {
  
	Enumeration keys = mHashtable.keys();
	String[] liste=new String[mHashtable.size()];
	int i=0;
	while (keys.hasMoreElements())   
        liste[i++]  = (String) keys.nextElement(); 

	return liste;	
  }
  
  /*
  * retourne la valeur demandee selon l'offset
  */
  public String getVal(int offset, char[] data) {
  
	String val="";
	int i=0;
	for(i=0; i<4; i++){
		if(data[i+offset]=='*') break;
		val+=String.valueOf(data[i+offset]); 
	}
    return val;
  }
  /*
  * retourne la valeur maximale du noeud passe en parametre
  */
  public String getMax(String noeud){
  
	char[] data=null;
	try {	
	rs = RecordStore.openRecordStore(mRecordStoreName, true);
	Integer value = (Integer) mHashtable.get(noeud);
	
	data=new String(rs.getRecord(value.intValue())).toCharArray();
	
    }catch(Exception e){
	    //Afficher Alert	
	} 
	
	return getVal(MAX, data);
	
  }
  /*
  * calcule et retourne la moyenne
  */
  public String setMoy(String max, String min){
  
	int moy=(int)((Integer.parseInt(max)+Integer.parseInt(min))/2);
	
	return new Integer(moy).toString();
  }
  
  /*
  * retourne l'offset
  */
  public int getOffset(char[] data){
  
    String val="";
	int i=0;
	for(i=0; i<4; i++){
		if(data[i+OFFSET]=='*') break;
		val+=String.valueOf(data[i+OFFSET]); 
	}
    return Integer.parseInt(val);
  }
  
  /*
  * retourne le nombre de noeud qu'on vigile
  */
  public String getNum() {
    return new Integer(mHashtable.size()).toString();
  }
  
  /*
  * le recordStore est persistant, prevoir une liberation
  */
  public void emptyRecordStore(){
  	
    try {
      RecordStore.deleteRecordStore(mRecordStoreName);
	  
	}
    catch(Exception e){
	    //Afficher Alert	
	} 
  }

  /*
  * recoit le noeudId et la temp et se charge de mettre a jour la base de donnee
  */
  public void put(String key, String value) {
  
	try {		
		if(mHashtable.containsKey(key)){ 
		
			Integer rId=(Integer)mHashtable.get(key);//obtenir le recordId correspondant au noeudId
			update(rId.intValue(), value); //mettre a jour les donnees
		
		}
		else{		    
		    createRecord( key, value);
		}	 
	} 
	catch(RecordStoreException rse){
	
		//Afficher Alert	
	}
	
  }
  
  /*
  * cree un record si le noeudId est nouveau
  */
  void createRecord(String key, String val)throws RecordStoreException{

    rs = RecordStore.openRecordStore(mRecordStoreName, true);
    
    char[] data= new char[36];
	for(int i=0; i<data.length; i++) data[i]='*';//initialiser data
    int offset=0; 
	inserer(offset, val, data);// mettre la valeur dans data 
	inserer(MIN, val, data);//mettre min
	inserer(MAX, val, data);//mettre max
	inserer(MOY, val, data);//mettre moy
	
	offset=(4+offset) % 20;//incrementer offset
	inserer(OFFSET, new Integer(offset).toString(), data);// inserer offset
    byte[] raw = new String(data).getBytes();
    int recordId=rs.addRecord(raw, 0, raw.length);

	mHashtable.put(key, new Integer(recordId));
	
	if (rs != null)
        rs.closeRecordStore();
	
  }
  
  /*
  * insere un String dans char[] array a l'endroit specifie par offset
  */
  void inserer(int offset, String value, char[]array){
  
	value.getChars(0,value.length(), array, offset);
     
  }
  
  /*
  * mettre a jour les temperatures quad le noeud existe deja dans base de donnee
  */
  void update(int id, String val)throws RecordStoreException{
	
	rs = RecordStore.openRecordStore(mRecordStoreName, true);
	char[] data=new String(rs.getRecord(id)).toCharArray();
	String min =getVal(MIN, data);          
	if(val.compareTo(min)<0) {inserer(MIN, val, data); min=val;}
	String max =getVal(MAX, data);        
	if(val.compareTo(max)>0) {inserer(MAX, val, data); max=val;}
	String moy=setMoy(max, min);           
	inserer(MOY, moy, data);
	int offset=getOffset(data);            
	inserer(offset, val, data);
	offset=(4+offset) % 20;//incrementer offset
	if(offset==0)										
		inserer(OFFSET, "0*", data);
	inserer(OFFSET, new Integer(offset).toString(), data);// inserer offset

	byte[] raw = new String(data).getBytes();
    rs.setRecord(id, raw, 0, raw.length);
	         
	if (rs != null)
		rs.closeRecordStore();
  }
  
  /*
  * retourne toutes les statistiques se tous les noeuds presents dans la base de donnee
  */
   
  String print(){
 
	String pref ="total noeud "+getNum()+"\n";
	Enumeration keys = mHashtable.keys();
	
	try{
		while (keys.hasMoreElements()) {
	  
        String key = (String) keys.nextElement();
        Integer value = (Integer) mHashtable.get(key);

		pref+="node "+key +": "+getStat(value.intValue());

		}	
	
	}catch(RecordStoreException res){
	    //do something
	}
	
	
	
	return pref;
  }
  
}
